home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / gfx / fract / FlashMandelWOS.lha / FlashMandel / Developer / Modules / React / FM_InfoReq_React.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-02  |  7.9 KB  |  358 lines
  1. /*
  2.  *  FM_InfoReq_React.c
  3.  *
  4.  *  Requester for info-request with reaction-support
  5.  *  $VER: V2.0, 13.10.2001
  6.  *  Coded by Edgar Schwan
  7.  */
  8.  
  9. #include <intuition/gadgetclass.h>
  10. #include <intuition/classusr.h>
  11. #include <intuition/screens.h>
  12. #include <classes/window.h>
  13. #include <dos/dos.h>
  14.  
  15. #include <clib/intuition_protos.h>
  16. #include <clib/exec_protos.h>
  17. #include <clib/graphics_protos.h>
  18. #include <clib/alib_protos.h>
  19.  
  20. #include <pragmas/intuition_pragmas.h>
  21. #include <pragmas/exec_pragmas.h>
  22. #include <pragmas/graphics_pragmas.h>
  23.  
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26.  
  27. #include "FM_InfoReq_React.h"
  28. #include "FM_ReactionBasics.h"
  29. #include "FM_Reaction.h"
  30. #include "FM_ReactionCD.h"
  31.  
  32. extern ULONG *PALETTE;
  33.  
  34. struct ReactWinData *info_rwd = NULL;
  35. struct ReactWinData *workgroup_rwd = NULL;
  36.  
  37. /*    Do_InfoRequest(): info-requester (full handling).
  38.  
  39.         SYNOPSIS: void = Do_InfoRequest
  40.                         (
  41.                         struct Window      *Win;
  42.                         char                  *PubScreenName;
  43.                         WORD                     Left;
  44.                         WORD                    Top;
  45.                         );
  46.  
  47.         INPUTS:        Win:
  48.                             Pointer to the parent-window.
  49.  
  50.                         PubScreenName:
  51.                             name of the public-screen, where the window should appear.
  52.  
  53.                         Left:
  54.                             Left edge of palette-window (not supported yet).
  55.  
  56.                         Top:
  57.                             Top edge of palette-window (not supported yet).
  58.  
  59.         RETURNS:        -
  60. */
  61.  
  62. void Do_InfoRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  63. {
  64. LONG result = RESULT_NOTHING;
  65. ULONG waitsigs, mask;
  66.  
  67. if (OpenInfoReqWindow(PubScreenName) == TRUE) {
  68.     waitsigs = info_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  69.  
  70.     while(result == RESULT_NOTHING) {
  71.         mask = Wait(waitsigs);
  72. #ifndef NDEBUG
  73.         printf("mask: %lX\n", mask);
  74. #endif /*NDEBUG*/
  75.         if (mask & info_rwd->RWD_WSignals) {
  76.             result = HandleInfoReqWindow(Win, PubScreenName);
  77.             }
  78.         if (mask & SIGBREAKF_CTRL_C) {
  79.             result = RESULT_CANCEL;
  80.             }
  81.         }
  82.  
  83.     CloseInfoReqWindow();
  84.     } else DisplayError(Win, TXT_ERR_Window, 5L);
  85.  
  86. LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
  87. }
  88.  
  89. /*    OpenInfoReqWindow(): open window of info-requester.
  90.  
  91.         SYNOPSIS: BOOL res = OpenInfoReqWindow
  92.                         (
  93.                         char                  *PubScreenName;
  94.                         );
  95.  
  96.         INPUTS:        PubScreenName:
  97.                             name of the public-screen, where the window should appear.
  98.  
  99.         RETURNS:        res:
  100.                             TRUE, if successfull.
  101. */
  102.  
  103. BOOL OpenInfoReqWindow(char *PubScreenName)
  104. {
  105. if (info_rwd = OpenReactionWindow(WIN_INFO_ID, GROUP_Info_ID, PubScreenName)) {
  106.     return(TRUE);
  107.     }
  108. return(FALSE);
  109. }
  110.  
  111. /*    CloseInfoReqWindow(): close window of info-requester.
  112.  
  113.         SYNOPSIS: void = CloseInfoReqWindow
  114.                         (
  115.                         void
  116.                         );
  117.  
  118.         INPUTS:        -
  119.  
  120.         RETURNS:        -
  121. */
  122.  
  123. void CloseInfoReqWindow(void)
  124. {
  125. CloseReactionWindow(info_rwd);
  126. }
  127.  
  128. /*    HandleInfoReqWindow(): Handle the messages of the info-requester.
  129.  
  130.         SYNOPSIS: LONG res = HandlePalettePrefWindow
  131.                         (
  132.                         struct Window    *Win;
  133.                         char                *PubScreenName;
  134.                         );
  135.  
  136.         INPUTS:        Win:
  137.                             Pointer to a window-structure.
  138.  
  139.                         PubScreenName:
  140.                             name of the public-screen, where windows should appear.
  141.  
  142.         RETURNS:        res:
  143.                             result of messages:    RESULT_NOTHING -> nothing happens.
  144.                                                         RESULT_CANCEL  -> user wants to quit without a change.
  145.                                                         RESULT_OK      -> accept changes and quit.
  146. */
  147.  
  148. LONG HandleInfoReqWindow(struct Window *Win, char *PubScreenName)
  149. {
  150. LONG rc = RESULT_NOTHING;
  151. ULONG result, code;
  152.  
  153. while((result = DoMethod(info_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  154.  
  155. #ifndef NDEBUG
  156.     printf("result: %ld\n", result);
  157. #endif /*NDEBUG*/
  158.  
  159.     switch (result & WMHI_CLASSMASK) {
  160.         case WMHI_CLOSEWINDOW:
  161.             rc = RESULT_CANCEL;
  162.             break;
  163.  
  164.         case WMHI_GADGETUP:
  165.             switch (result & RL_GADGETMASK) {
  166.                 case Info_BUTTON_OK:
  167.                     rc = RESULT_OK;
  168.                     break;
  169.                 case Info_BUTTON_More:
  170.                     SetAttrs(info_rwd->RWD_WindowObject, WA_BusyPointer, TRUE);
  171.                     Do_WorkgroupRequest(info_rwd->RWD_IWindow, PubScreenName, 50, 50);
  172.                     SetAttrs(info_rwd->RWD_WindowObject, WA_BusyPointer, FALSE);
  173.                     rc = RESULT_OK;
  174.                     break;
  175. #ifndef NDEBUG
  176.                 default:
  177.                     printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
  178.                     DisplayBeep(NULL);
  179.                     break;
  180. #endif /*NDEBUG*/
  181.                 }
  182.             break;
  183.  
  184.         case WMHI_ICONIFY:
  185.             DoMethod(info_rwd->RWD_WindowObject, WM_ICONIFY);
  186.             GetAttr(WINDOW_Window, info_rwd->RWD_WindowObject, (ULONG *) &info_rwd->RWD_IWindow);
  187.             break;
  188.  
  189.         case WMHI_UNICONIFY:
  190.             DoMethod(info_rwd->RWD_WindowObject, WM_OPEN);
  191.             GetAttr(WINDOW_Window, info_rwd->RWD_WindowObject, (ULONG *) &info_rwd->RWD_IWindow);
  192.             break;
  193. #ifndef NDEBUG
  194.         default:
  195.             printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
  196.             DisplayBeep(NULL);
  197.             break;
  198. #endif /*NDEBUG*/
  199.         }
  200.     }
  201. return(rc);
  202. }
  203.  
  204. /*    Do_WorkgroupRequest(): workgroup-requester (full handling).
  205.  
  206.         SYNOPSIS: void = Do_WorkgroupRequest
  207.                         (
  208.                         struct Window      *Win;
  209.                         char                  *PubScreenName;
  210.                         WORD                     Left;
  211.                         WORD                    Top;
  212.                         );
  213.  
  214.         INPUTS:        Win:
  215.                             Pointer to the parent-window.
  216.  
  217.                         PubScreenName:
  218.                             name of the public-screen, where the window should appear.
  219.  
  220.                         Left:
  221.                             Left edge of palette-window.
  222.  
  223.                         Top:
  224.                             Top edge of palette-window.
  225.  
  226.         RETURNS:        -
  227. */
  228.  
  229. void Do_WorkgroupRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
  230. {
  231. LONG result = RESULT_NOTHING;
  232. ULONG waitsigs, mask;
  233.  
  234. if (OpenWorkgroupReqWindow(PubScreenName) == TRUE) {
  235.     waitsigs = workgroup_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  236.  
  237.     while(result == RESULT_NOTHING) {
  238.         mask = Wait(waitsigs);
  239. #ifndef NDEBUG
  240.         printf("mask: %lX\n", mask);
  241. #endif /*NDEBUG*/
  242.         if (mask & workgroup_rwd->RWD_WSignals) {
  243.             result = HandleWorkgroupReqWindow(Win);
  244.             }
  245.         if (mask & SIGBREAKF_CTRL_C) {
  246.             result = RESULT_CANCEL;
  247.             }
  248.         }
  249.  
  250.     CloseWorkgroupReqWindow();
  251.     } else DisplayError(Win, TXT_ERR_Window, 5L);
  252. }
  253.  
  254. /*    OpenWorkgroupReqWindow(): open window of workgroup-requester.
  255.  
  256.         SYNOPSIS: BOOL res = OpenWorkgroupReqWindow
  257.                         (
  258.                         char                  *PubScreenName;
  259.                         );
  260.  
  261.         INPUTS:        PubScreenName:
  262.                             name of the public-screen, where the window should appear.
  263.  
  264.         RETURNS:        res:
  265.                             TRUE, if successfull.
  266. */
  267.  
  268. BOOL OpenWorkgroupReqWindow(char *PubScreenName)
  269. {
  270. if (workgroup_rwd = OpenReactionWindow(WIN_WORK_ID, GROUP_Work_ID, PubScreenName)) {
  271.     return(TRUE);
  272.     }
  273. return(FALSE);
  274. }
  275.  
  276. /*    CloseWorkgroupReqWindow(): close window of workgroup-requester.
  277.  
  278.         SYNOPSIS: void = CloseWorkgroupReqWindow
  279.                         (
  280.                         void
  281.                         );
  282.  
  283.         INPUTS:        -
  284.  
  285.         RETURNS:        -
  286. */
  287.  
  288. void CloseWorkgroupReqWindow(void)
  289. {
  290. CloseReactionWindow(workgroup_rwd);
  291. }
  292.  
  293. /*    HandleWorkgroupReqWindow(): Handle the messages of the workgroup-requester.
  294.  
  295.         SYNOPSIS: BOOL = HandleWorkgroupReqWindow
  296.                         (
  297.                         struct Window    *Win;
  298.                         );
  299.  
  300.         INPUTS:        Win:
  301.                             Pointer to a window-structure.
  302.  
  303.         RETURNS:        res:
  304.                             result of messages:    RESULT_NOTHING -> nothing happens.
  305.                                                         RESULT_CANCEL  -> user wants to quit without a change.
  306.                                                         RESULT_OK      -> accept changes and quit.
  307. */
  308.  
  309. LONG HandleWorkgroupReqWindow(struct Window *Win)
  310. {
  311. LONG rc = RESULT_NOTHING;
  312. ULONG result, code;
  313.  
  314. while((result = DoMethod(workgroup_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  315.  
  316. #ifndef NDEBUG
  317.     printf("result: %ld\n", result);
  318. #endif /*NDEBUG*/
  319.  
  320.     switch (result & WMHI_CLASSMASK) {
  321.         case WMHI_CLOSEWINDOW:
  322.             rc = RESULT_CANCEL;
  323.             break;
  324.  
  325.         case WMHI_GADGETUP:
  326.             switch (result & RL_GADGETMASK) {
  327.                 case Work_BUTTON_OK:
  328.                     rc = RESULT_OK;
  329.                     break;
  330. #ifndef NDEBUG
  331.                 default:
  332.                     printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
  333.                     DisplayBeep(NULL);
  334.                     break;
  335. #endif /*NDEBUG*/
  336.                 }
  337.             break;
  338.  
  339.         case WMHI_ICONIFY:
  340.             DoMethod(workgroup_rwd->RWD_WindowObject, WM_ICONIFY);
  341.             GetAttr(WINDOW_Window, workgroup_rwd->RWD_WindowObject, (ULONG *) &workgroup_rwd->RWD_IWindow);
  342.             break;
  343.  
  344.         case WMHI_UNICONIFY:
  345.             DoMethod(workgroup_rwd->RWD_WindowObject, WM_OPEN);
  346.             GetAttr(WINDOW_Window, workgroup_rwd->RWD_WindowObject, (ULONG *) &workgroup_rwd->RWD_IWindow);
  347.             break;
  348. #ifndef NDEBUG
  349.         default:
  350.             printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
  351.             DisplayBeep(NULL);
  352.             break;
  353. #endif /*NDEBUG*/
  354.         }
  355.     }
  356. return(rc);
  357. }
  358.